#!/usr/bin/env node

/**
 * 异步架构测试脚本
 * 验证net::ERR_CONNECTION_RESET问题是否已解决
 *
 * 测试流程：
 * 1. 检查系统状态
 * 2. 提交AI推理任务
 * 3. 验证快速响应（<500ms）
 * 4. 轮询任务状态
 * 5. 验证任务完成
 */

const axios = require('axios');
const FormData = require('form-data');
const fs = require('fs');
const path = require('path');

// 测试配置
const API_BASE_URL = 'http://localhost:4000';
const TEST_IMAGE_PATH = './colonoscopy_2024_01_15_patient001.jpg'; // 测试图片
const TEST_PATIENT_CODE = 'TEST_ASYNC_' + Date.now();

// 测试结果
let testResults = {
  systemCheck: false,
  quickResponse: false,
  taskAccepted: false,
  taskCompleted: false,
  noConnectionReset: true,
  responseTime: 0,
  totalTime: 0,
  errors: []
};

/**
 * 测试系统状态
 */
async function testSystemStatus() {
  try {
    console.log('🔍 [1/5] 测试系统状态...');

    const response = await axios.get(`${API_BASE_URL}/health`, { timeout: 5000 });

    if (response.data.success) {
      console.log('✅ [1/5] 系统状态正常');
      console.log('📊 系统信息:', {
        version: response.data.data.version,
        queueInitialized: response.data.data.queueInitialized,
        workerStarted: response.data.data.workerStarted,
        uptime: response.data.data.uptime
      });

      testResults.systemCheck = true;
      return true;
    } else {
      throw new Error('系统健康检查失败');
    }

  } catch (error) {
    console.error('❌ [1/5] 系统状态检查失败:', error.message);
    testResults.errors.push('系统状态检查失败: ' + error.message);
    return false;
  }
}

/**
 * 测试队列状态
 */
async function testQueueStatus() {
  try {
    console.log('🔍 [2/5] 测试队列状态...');

    const response = await axios.get(`${API_BASE_URL}/queue/status`, { timeout: 5000 });

    if (response.data.success) {
      console.log('✅ [2/5] 队列状态正常');
      console.log('📈 队列统计:', response.data.data);
      return true;
    } else {
      console.warn('⚠️ [2/5] 队列系统未初始化，系统降级运行');
      return true; // 降级模式也算通过
    }

  } catch (error) {
    console.warn('⚠️ [2/5] 队列状态检查失败，系统可能降级运行:', error.message);
    return true; // 队列检查失败不影响整体测试
  }
}

/**
 * 获取认证token
 */
async function getAuthToken() {
  try {
    console.log('🔐 [3/5] 获取认证token...');

    const response = await axios.post(`${API_BASE_URL}/api/doctors/login`, {
      username: 'admin',
      password: 'admin123'
    }, { timeout: 5000 });

    if (response.data.success) {
      console.log('✅ [3/5] 认证成功');
      return response.data.data.token;
    } else {
      throw new Error(response.data.message || '登录失败');
    }

  } catch (error) {
    console.error('❌ [3/5] 认证失败:', error.message);
    testResults.errors.push('认证失败: ' + error.message);
    return null;
  }
}

/**
 * 提交AI推理任务
 */
async function submitAITask(token) {
  try {
    console.log('📤 [4/5] 提交AI推理任务...');

    if (!fs.existsSync(TEST_IMAGE_PATH)) {
      throw new Error(`测试图片不存在: ${TEST_IMAGE_PATH}`);
    }

    const startTime = Date.now();

    // 创建表单数据
    const form = new FormData();
    form.append('image', fs.createReadStream(TEST_IMAGE_PATH));
    form.append('patient_code', TEST_PATIENT_CODE);
    form.append('clinical_text', '异步架构测试病例');

    // 提交任务
    const response = await axios.post(
      `${API_BASE_URL}/api/scoring/submit`,
      form,
      {
        headers: {
          ...form.getHeaders(),
          'Authorization': `Bearer ${token}`
        },
        timeout: 10000 // 10秒超时
      }
    );

    const responseTime = Date.now() - startTime;
    testResults.responseTime = responseTime;

    if (response.data.success && response.status === 202) {
      console.log('✅ [4/5] AI任务提交成功');
      console.log('⚡ 响应时间:', responseTime + 'ms');
      console.log('📋 任务信息:', {
        task_id: response.data.data.task_id,
        status: response.data.data.status,
        message: response.data.data.message,
        queued_successfully: response.data.data.queued_successfully
      });

      // 验证快速响应（应该<500ms）
      if (responseTime < 500) {
        testResults.quickResponse = true;
        console.log('🚀 快速响应验证通过 (<500ms)');
      } else {
        console.warn('⚠️ 响应时间较慢 (>500ms):', responseTime + 'ms');
      }

      testResults.taskAccepted = true;
      return response.data.data.task_id;

    } else {
      throw new Error(response.data.message || '任务提交失败');
    }

  } catch (error) {
    console.error('❌ [4/5] AI任务提交失败:', error.message);

    // 检查是否是连接重置错误
    if (error.code === 'ECONNRESET' || error.message.includes('Connection reset')) {
      testResults.noConnectionReset = false;
      console.error('💥 检测到连接重置错误！异步架构未能解决问题');
    }

    testResults.errors.push('AI任务提交失败: ' + error.message);
    return null;
  }
}

/**
 * 轮询任务状态
 */
async function pollTaskStatus(token, taskId) {
  try {
    console.log('🔄 [5/5] 轮询任务状态...');

    const maxPolls = 30; // 最多轮询30次（30秒）
    const pollInterval = 1000; // 1秒间隔

    for (let i = 0; i < maxPolls; i++) {
      try {
        const response = await axios.post(
          `${API_BASE_URL}/api/scoring/status`,
          { task_id: taskId },
          {
            headers: {
              'Authorization': `Bearer ${token}`
            },
            timeout: 5000
          }
        );

        if (response.data.success) {
          const status = response.data.data.status;
          const statusName = response.data.data.status_name;

          console.log(`📊 任务状态 [${i + 1}/${maxPolls}]: ${status} (${statusName})`);

          if (status === 3) { // 已完成
            console.log('✅ [5/5] 任务完成');
            console.log('🎯 AI结果:', {
              score: response.data.data.ai_result?.score,
              severity: response.data.data.ai_result?.severity_name,
              confidence: response.data.data.ai_result?.confidence
            });

            testResults.taskCompleted = true;
            return true;

          } else if (status === 4) { // 失败
            console.error('❌ [5/5] 任务失败:', response.data.data.error_message);
            testResults.errors.push('任务执行失败: ' + response.data.data.error_message);
            return false;
          }

          // 继续轮询
          await new Promise(resolve => setTimeout(resolve, pollInterval));

        } else {
          console.warn('⚠️ 状态查询失败:', response.data.message);
        }

      } catch (error) {
        console.warn('⚠️ 轮询错误:', error.message);
        await new Promise(resolve => setTimeout(resolve, pollInterval));
      }
    }

    console.warn('⚠️ [5/5] 任务轮询超时');
    testResults.errors.push('任务轮询超时');
    return false;

  } catch (error) {
    console.error('❌ [5/5] 任务状态轮询失败:', error.message);
    testResults.errors.push('任务状态轮询失败: ' + error.message);
    return false;
  }
}

/**
 * 生成测试报告
 */
function generateTestReport() {
  console.log('\n' + '='.repeat(60));
  console.log('📋 异步架构测试报告');
  console.log('='.repeat(60));

  const passedTests = Object.values(testResults).filter(val => typeof val === 'boolean' && val).length;
  const totalTests = Object.values(testResults).filter(val => typeof val === 'boolean').length;
  const successRate = Math.round((passedTests / totalTests) * 100);

  console.log(`✅ 通过测试: ${passedTests}/${totalTests} (${successRate}%)`);
  console.log(`⚡ 响应时间: ${testResults.responseTime}ms`);
  console.log(`⏱️ 总测试时间: ${testResults.totalTime}ms`);

  console.log('\n📊 详细结果:');
  console.log(`  系统状态检查: ${testResults.systemCheck ? '✅ 通过' : '❌ 失败'}`);
  console.log(`  快速响应验证: ${testResults.quickResponse ? '✅ 通过' : '❌ 失败'}`);
  console.log(`  任务接受验证: ${testResults.taskAccepted ? '✅ 通过' : '❌ 失败'}`);
  console.log(`  任务完成验证: ${testResults.taskCompleted ? '✅ 通过' : '❌ 失败'}`);
  console.log(`  无连接重置: ${testResults.noConnectionReset ? '✅ 通过' : '❌ 失败'}`);

  if (testResults.errors.length > 0) {
    console.log('\n❌ 错误列表:');
    testResults.errors.forEach((error, index) => {
      console.log(`  ${index + 1}. ${error}`);
    });
  }

  // 关键结论
  console.log('\n🎯 关键结论:');
  if (testResults.noConnectionReset && testResults.quickResponse && testResults.taskAccepted) {
    console.log('🎉 异步架构成功解决了net::ERR_CONNECTION_RESET问题！');
    console.log('✨ 系统现在可以在不阻塞主进程的情况下处理AI推理任务');
  } else {
    console.log('⚠️ 异步架构可能仍需要进一步优化');
    if (!testResults.noConnectionReset) {
      console.log('💥 连接重置问题仍然存在');
    }
    if (!testResults.quickResponse) {
      console.log('⏰ 响应时间未达到预期(<500ms)');
    }
  }

  console.log('='.repeat(60));

  return {
    success: testResults.noConnectionReset && testResults.quickResponse && testResults.taskAccepted,
    score: successRate,
    results: testResults
  };
}

/**
 * 主测试函数
 */
async function main() {
  console.log('🚀 开始异步架构测试...');
  console.log('🎯 目标：验证net::ERR_CONNECTION_RESET问题是否已解决');
  console.log('⏰ 测试开始时间:', new Date().toISOString());
  console.log('='.repeat(60));

  const startTime = Date.now();

  try {
    // 1. 系统状态检查
    const systemOk = await testSystemStatus();
    if (!systemOk) {
      console.error('❌ 系统状态检查失败，无法继续测试');
      return generateTestReport();
    }

    // 2. 队列状态检查
    await testQueueStatus();

    // 3. 获取认证token
    const token = await getAuthToken();
    if (!token) {
      console.error('❌ 认证失败，无法继续测试');
      return generateTestReport();
    }

    // 4. 提交AI任务
    const taskId = await submitAITask(token);
    if (!taskId) {
      console.error('❌ 任务提交失败，无法继续测试');
      return generateTestReport();
    }

    // 5. 轮询任务状态
    await pollTaskStatus(token, taskId);

    testResults.totalTime = Date.now() - startTime;

    // 生成测试报告
    const report = generateTestReport();

    // 退出代码
    process.exit(report.success ? 0 : 1);

  } catch (error) {
    console.error('💥 测试过程中发生未捕获错误:', error);
    testResults.errors.push('未捕获错误: ' + error.message);
    testResults.totalTime = Date.now() - startTime;

    const report = generateTestReport();
    process.exit(1);
  }
}

// 运行测试
if (require.main === module) {
  main();
}

module.exports = {
  main,
  testSystemStatus,
  testQueueStatus,
  submitAITask,
  pollTaskStatus,
  generateTestReport
};